home *** CD-ROM | disk | FTP | other *** search
/ Aminet 25 / Aminet 25 (1998)(GTI - Schatztruhe)[!][Jun 1998].iso / Aminet / misc / emu / atari800_tr.lzh / gtia.c < prev    next >
Encoding:
C/C++ Source or Header  |  1998-02-26  |  21.9 KB  |  1,063 lines
  1. /*
  2.  * Scanline Generation
  3.  * Player Missile Graphics
  4.  * Collision Detection
  5.  * Playfield Priorities
  6.  * Issues cpu cycles during frame redraw.
  7.  */
  8.  
  9. #include <stdio.h>
  10. #include <string.h>
  11.  
  12. #ifndef AMIGA
  13. #include "config.h"
  14. #endif
  15.  
  16. #include "atari.h"
  17. #include "cpu.h"
  18. #include "pia.h"
  19. #include "pokey.h"
  20. #include "gtia.h"
  21. #include "antic.h"
  22. #include "pia.h"
  23. #include "platform.h"
  24. #include "pokey11.h"
  25. #include "mem.h"
  26. #include "sio.h"
  27.  
  28. #define FALSE 0
  29. #define TRUE 1
  30.  
  31. static char *rcsid = "$Id: gtia.c,v 1.30 1998/02/17 thor,david Exp $";
  32.  
  33. extern int DELAYED_SERIN_IRQ;
  34. extern int DELAYED_SEROUT_IRQ;
  35. extern int DELAYED_XMTDONE_IRQ;
  36.  
  37. UBYTE COLBK;
  38. UBYTE COLPF0;
  39. UBYTE COLPF1;
  40. UBYTE COLPF2;
  41. UBYTE COLPF3;
  42. UBYTE COLPM0;
  43. UBYTE COLPM1;
  44. UBYTE COLPM2;
  45. UBYTE COLPM3;
  46. UBYTE GRAFM;
  47. UBYTE GRAFP0;
  48. UBYTE GRAFP1;
  49. UBYTE GRAFP2;
  50. UBYTE GRAFP3;
  51. UBYTE HPOSP0;
  52. UBYTE HPOSP1;
  53. UBYTE HPOSP2;
  54. UBYTE HPOSP3;
  55. UBYTE HPOSM0;
  56. UBYTE HPOSM1;
  57. UBYTE HPOSM2;
  58. UBYTE HPOSM3;
  59. UBYTE SIZEP0;
  60. UBYTE SIZEP1;
  61. UBYTE SIZEP2;
  62. UBYTE SIZEP3;
  63. UBYTE SIZEM;
  64. UBYTE PRIOR;
  65. UBYTE GRACTL;
  66. UBYTE VDELAY;
  67. int delayp0,delayp1,delayp2,delayp3;  /* VDelay mirrors */
  68. int delaym0,delaym1,delaym2,delaym3;
  69. int artefacts;
  70.  
  71.  
  72. /* Collision stuff. There's no need to mirror the precise hardware registers.
  73.    We keep all the stuff here and extract the information as soon as needed.
  74.  
  75.    Please note that the ordering of these flag fields are a bit strange.
  76.    Namely index #0 relates to missile #3. That is due to the sorting
  77.    of the bits in the missile graphics register for faster access.
  78.    Players, however, are sorted straigh. Wierdos! */
  79.  
  80. UBYTE Missile_Playfield[4];    /* Missile-playfield collisions */
  81. UBYTE Missile_Player[4];       /* Missile-player collisions */
  82. UBYTE Player_Playfield[4];     /* Player-playfield collisions */
  83. UBYTE Player_Player[4];        /* Player-player collisions */
  84.  
  85. /* due to the way how the collision detection works currently, not all bits
  86.    are set consistently in these bits. Only higher order players can collide
  87.    with lower order players, missiles with players. It's the task of the
  88.    hardware access registers to gain the right information from these bits.
  89.  
  90.    Player/missile- playfield collisions work straight, though. */
  91.  
  92. /*
  93.     *****************************************************************
  94.     *                                *
  95.     *    Section            :    Player Missile Graphics    *
  96.     *    Original Author        :    David Firth        *
  97.     *    Date Written        :    28th May 1995        *
  98.     *    Version            :    1.0            *
  99.     *                                *
  100.     *****************************************************************
  101. */
  102.  
  103. static int global_hposp0;
  104. static int global_hposp1;
  105. static int global_hposp2;
  106. static int global_hposp3;
  107. static int global_hposm[4];  /* sorted in reverse order, #0 is missile #3 */
  108. static int global_sizep0;
  109. static int global_sizep1;
  110. static int global_sizep2;
  111. static int global_sizep3;
  112. static int global_sizem[4];
  113.  
  114. /*
  115.     =========================================
  116.     Width of each bit within a Player/Missile
  117.     =========================================
  118. */
  119.  
  120. static UBYTE pm_scanline[ATARI_MODULO+PLAYER_OFFSET];
  121.  
  122. UBYTE colour_lookup[9];
  123. int colour_translation_table[256];
  124.  
  125. static int GTIA_XLate[]={0,1,2,3,4,5,6,7,8,8,8,8,4,5,6,7};
  126. static int pf_collision_bit[10] = {
  127.   0x00, 0x00, 0x00, 0x00,
  128.   0x01, 0x02, 0x04, 0x08,
  129.   0x00, 0x02  /* this last entry is for collisions with the fiddled color */
  130. };
  131.  
  132. /* artefact color #1, indexed by the background hue. Must be setup correctly */
  133. static UBYTE ArteF1[]={0x40,0x40,0x40,0x40,0x40,0x40,0x40,0x40,
  134.                0x40,0x40,0x40,0x40,0x40,0x40,0x40,0x40};
  135.  
  136. /* artefact color #2, indexed by the background hue. Still to be done */
  137. static UBYTE ArteF2[]={0x90,0x90,0x90,0x90,0x90,0x90,0x90,0x90,
  138.                0x90,0x90,0x90,0x90,0x90,0x90,0x90,0x90};
  139.  
  140.  
  141. int next_console_value = 7;
  142. extern UWORD regPC;
  143.  
  144. UWORD pl0adr;
  145. UWORD pl1adr;
  146. UWORD pl2adr;
  147. UWORD pl3adr;
  148. UWORD m0123adr;
  149.  
  150. static int PM_XPos[256];
  151. static UBYTE PM_Width[4] = { 2, 4, 2, 8};
  152. static void Setup_Priority(void);
  153.  
  154.  
  155. /* Object IDs for the priority engine */
  156.  
  157. /* First, player and missiles */
  158. #define ID_PLAYER0     0x10
  159. #define ID_MISSILE0    0x11
  160. #define ID_PLAYER1     0x12
  161. #define ID_MISSILE1    0x13
  162. #define ID_PLAYER2     0x14
  163. #define ID_MISSILE2    0x15
  164. #define ID_PLAYER3     0x16
  165. #define ID_MISSILE3    0x17
  166.  
  167. /* Playfield graphics. Some specials for GTIA 0x80 mode - graphics 10 */
  168. #define ID_PFSP0       0x00 
  169. #define ID_PFSP1       0x01
  170. #define ID_PFSP2       0x02
  171. #define ID_PFSP3       0x03
  172. #define ID_PF0         0x04
  173. #define ID_PF1         0x05
  174. #define ID_PF2         0x06
  175. #define ID_PF3         0x07
  176. #define ID_PFBACK      0x08
  177. #define ID_TABLESIZE   0x20
  178.  
  179.  
  180.  
  181. /* Another implementation of the priority engine */
  182. static int pl01beatspf;     /* true if player 0,1 is on top of pf 0,1 */
  183. static int pf01beatspl;     /* true if playfield 0,1 is on top of player 0,1 */
  184. static int pl23beatspf;     /* true if player 2,3 is on top of pf 2,3 */
  185. static int pf23beatspl;     /* true if playfield 2,3 is on top of player 2,3 */
  186. static int pl02beatspl;     /* true if player 0,2 is on top of player 1,3 */
  187. static int pfbeatspl;       /* true if player 0,1 behind pf 2,3 */
  188. static int plbeatspf;       /* true if player 2,3 in front of pf 0,1 */
  189. static int misslepf3;       /* true if missle 0-3 get pf3 as color */
  190.  
  191. static void Setup_Priority(void)
  192. {
  193. static UWORD lastpri=0xffff;
  194.  
  195.   if (lastpri==PRIOR)
  196.     return;
  197.  
  198.   misslepf3=FALSE;
  199.   pfbeatspl=FALSE;
  200.   plbeatspf=FALSE;
  201.   pl02beatspl=TRUE;
  202.   pf23beatspl=FALSE;
  203.   pl23beatspf=FALSE;
  204.   pf01beatspl=FALSE;
  205.   pl01beatspf=FALSE;
  206.  
  207.   if (PRIOR & 0x10)
  208.     misslepf3=TRUE;
  209.  
  210.   if (PRIOR & 0x20)
  211.     pl02beatspl=FALSE;
  212.  
  213.   if (PRIOR & 0x01) {
  214.     pl01beatspf=TRUE;
  215.     pl23beatspf=TRUE;
  216.     plbeatspf=TRUE;
  217.   }
  218.   if (PRIOR & 0x02) {
  219.     pl01beatspf=TRUE;
  220.     pf23beatspl=TRUE;
  221.   }
  222.   if (PRIOR & 0x04) {
  223.     pf01beatspl=TRUE;
  224.     pf23beatspl=TRUE;
  225.     pfbeatspl=TRUE;
  226.   }
  227.   if (PRIOR & 0x08) {
  228.     pf01beatspl=TRUE;
  229.     pl23beatspf=TRUE;
  230.   }
  231. }
  232.  
  233.  
  234. /* Run the priority engine. Get player pixel encoding and
  235.    playfield pixel mask, fiddle is TRUE for the special ANTIC F,2,3 mode
  236.    coloring, i.e. HIRES */
  237.  
  238. int PixelColor(int pf_pixel,int pm_pixel,int pf_color)
  239. {
  240. int pfcol,pfidx;
  241. int pl0=0,pl1=0,pl2=0,pl3=0;
  242. int pf0=0,pf2=0;
  243.  
  244.   pfcol=pf_color;
  245.   pfidx=pf_pixel;
  246.   if (pf_pixel==PF_COLPF1_FID) {
  247.     pfcol=colour_lookup[PF_COLPF2];
  248.     pfidx=PF_COLPF2;
  249.   }
  250.  
  251.   if ((pm_pixel & 0xf0) && misslepf3) {
  252.     pfcol=colour_lookup[PF_COLPF3];
  253.     pfidx=PF_COLPF3;
  254.   } else {
  255.     pm_pixel |= pm_pixel>>4;
  256.   }
  257.  
  258.   if (pm_pixel & 0x08) {
  259.     pl3=colour_lookup[PL_COLPL3];
  260.   }
  261.  
  262.   if (pm_pixel & 0x04) {
  263.     pl2=colour_lookup[PL_COLPL2];
  264.     if (pl02beatspl)
  265.       pl3=0;
  266.   }
  267.  
  268.   if (pm_pixel & 0x02) {
  269.     pl1=colour_lookup[PL_COLPL1];
  270.     pl2=pl3=0;
  271.   }
  272.  
  273.   if (pm_pixel & 0x01) {
  274.     pl0=colour_lookup[PL_COLPL0];
  275.     pl2=pl3=0;
  276.     if (pl02beatspl)
  277.       pl1=0;
  278.   }
  279.  
  280.   pl0 |= pl1;
  281.   pl2 |= pl3;
  282.   
  283.   if (pfidx==PF_COLPF0 || pfidx==PF_COLPF1) {
  284.     pf0 = pfcol;
  285.     if (pf01beatspl)
  286.       pl0 = 0;
  287.     if (!plbeatspf)
  288.       pl2 = 0;
  289.   }
  290.  
  291.   if (pfidx==PF_COLPF2 || pfidx==PF_COLPF3) {
  292.     pf2 = pfcol;
  293.     if (pf23beatspl)
  294.       pl2 = 0;
  295.     if (pfbeatspl)
  296.       pl0 = 0;
  297.   }
  298.  
  299.   if (pm_pixel & 0x03) {
  300.     if (pl01beatspf)
  301.       pf0 = 0;
  302.     if (!pfbeatspl)
  303.       pf2 = 0;
  304.   }
  305.  
  306.   if (pm_pixel & 0x0c) {
  307.     if (pl23beatspf)
  308.       pf2 = 0;
  309.     if (plbeatspf)
  310.       pf0 = 0;
  311.   }
  312.  
  313.   pf0 |= pl0;
  314.   pf2 |= pl2;
  315.  
  316.   pfcol = pf0 | pf2;
  317.   
  318.   if (pf_pixel==PF_COLPF1_FID) {
  319.     pfcol = (pfcol & 0xf0) | (colour_lookup[PF_COLPF1] & 0x0f);
  320.   }
  321.  
  322.   return pfcol;
  323. }
  324.  
  325. static int missile_mask[4] = {0x80,0x40,0x20,0x10};
  326.  
  327. void DisplayMissiles(int ofs)
  328. {
  329. unsigned int grafm = GRAFM;
  330. int i,j,sizem=0,mask=0;
  331. UBYTE *mplc=0,*mpfc=0;
  332. UBYTE *pmpos=0,*pfpos=0;
  333.  
  334.   for (i=0;i<8;i++) {
  335.     if ((i & 0x01)==0) {
  336.       int ih,hpos;
  337.       ih = i>>1;
  338.       sizem = global_sizem[ih];
  339.       hpos  = global_hposm[ih];
  340.       mask  = missile_mask[ih];
  341.       mplc  = Missile_Player+ih;
  342.       mpfc  = Missile_Playfield+ih;
  343.       pmpos = pm_scanline+hpos+PLAYER_OFFSET;
  344.       pfpos = scrn_ptr+hpos+ofs;
  345.     }
  346.  
  347.     if (grafm & 0x80) {
  348.       for (j=0;j<sizem;j++) {
  349.     *mpfc  |= pf_collision_bit[*pfpos];
  350.     *mplc  |= *pmpos;
  351.     *pmpos |= mask;
  352.     pmpos++;
  353.     pfpos++;
  354.       }
  355.     } else {
  356.       pmpos +=sizem;
  357.       pfpos +=sizem;
  358.     }
  359.     grafm <<= 1;
  360.   }
  361.  
  362. }
  363.  
  364. void DisplayPlayer(int ofs,unsigned int graf,int size,int hpos,int num)
  365. {
  366. int i,j;
  367. int coll=0,pmcol=0;
  368. UBYTE *pmpos,*pfpos;
  369. int mask;
  370.  
  371.  
  372.   pmpos = pm_scanline + hpos + PLAYER_OFFSET;
  373.   pfpos = scrn_ptr + hpos + ofs;
  374.   mask = 1<<num;
  375.  
  376.   for (i=0;i<8;i++) {
  377.     if (graf & 0x80) {
  378.       for (j=0;j<size;j++) {
  379.     pmcol  |= *pmpos;
  380.     *pmpos |= mask;
  381.     coll   |= pf_collision_bit[*pfpos];
  382.     pmpos ++;
  383.     pfpos ++;
  384.       }
  385.     } else {
  386.       pmpos += size;
  387.       pfpos += size;
  388.     }
  389.     graf <<= 1;
  390.   }
  391.  
  392.   Player_Playfield[num] |= coll;
  393.   Player_Player[num] |= pmcol;
  394. }
  395.  
  396.  
  397. /*
  398.    ======================================
  399.    Player/Missle Graphics service
  400.    routines for different GTIA modes
  401.    ======================================
  402. */
  403.  
  404. /* Ordinary display modes */
  405. void GTIA_Create00(UBYTE *pm,UBYTE *pf,int ofs)
  406. {
  407. int xpos;
  408. int pm_pixel,pf_pixel;
  409.  
  410.     for (xpos=0;xpos<ATARI_WIDTH;xpos++,pm++,pf++) {
  411.       
  412.       pm_pixel = *pm;
  413.       pf_pixel = pf[ofs];
  414.        
  415.       if (pm_pixel) {
  416.     *pf=PixelColor(pf_pixel,pm_pixel,colour_lookup[pf_pixel]) & 0xfe;
  417.       } else {
  418.     if (pf_pixel==PF_COLPF1_FID)
  419.       *pf = (colour_lookup[PF_COLPF1] & 0x0e) | (colour_lookup[PF_COLPF2] & 0xf0);
  420.     else
  421.       *pf = colour_lookup[pf_pixel] & 0xfe;
  422.       }
  423.     }
  424. }
  425.  
  426. /* Display with artefacts */
  427.  
  428. void GTIA_Create00AF(UBYTE *pm,UBYTE *pf,int ofs)
  429. {
  430. int xpos;
  431. int pm_pixel,pf_pixel,last,color,value,hue;
  432.  
  433.     pf_pixel = PF_COLBK;
  434.     for (xpos=0;xpos<ATARI_WIDTH;xpos++,pm++,pf++) {
  435.       
  436.       last = pf_pixel;
  437.       pm_pixel = *pm;
  438.       pf_pixel = pf[ofs];
  439.  
  440.       switch (pf_pixel) {
  441.       case PF_COLPF1_FID:
  442.     value = colour_lookup[PF_COLPF1] & 0x0e;
  443.     hue = colour_lookup[PF_COLPF2] & 0xf0;
  444.     color = value | hue;
  445.     if (last==PF_COLPF2) {
  446.       value += colour_lookup[PF_COLPF2] & 0x0e;
  447.       color=(value>>1) | ((xpos & 0x01)?(ArteF1[hue>>4]):(ArteF2[hue>>4]));
  448.     }
  449.     break;
  450.       case PF_COLPF2:
  451.     hue = colour_lookup[PF_COLPF2] & 0xf0;
  452.     value = colour_lookup[PF_COLPF1] & 0x0e;
  453.     color = colour_lookup[PF_COLPF2] & 0xfe;
  454.     if (last==PF_COLPF1_FID) {
  455.       value += color & 0x0e; 
  456.       color=(value>>1) | ((xpos & 0x01)?(ArteF2[hue>>4]):(ArteF1[hue>>4]));
  457.     }
  458.     break;
  459.       default:      
  460.     color=colour_lookup[pf_pixel] & 0xfe;
  461.     break;
  462.       }
  463.       
  464.       if (pm_pixel) {
  465.     *pf=PixelColor(pf_pixel,pm_pixel,color) & 0xfe;
  466.       } else {
  467.     *pf = color;
  468.       }
  469.     }
  470. }
  471.  
  472. /* Graphics 9 */
  473. void GTIA_Create40(UBYTE *pm,UBYTE *pf,int ofs)
  474. {
  475. int xpos;
  476. int pm_pixel,pf_pixel=0,nibble=0;
  477.  
  478.     for(xpos=0;xpos<ATARI_WIDTH;xpos++,pm++,pf++) {
  479.  
  480.       pm_pixel = *pm;
  481.  
  482.       if ((xpos & 0x03) == 0x00) {
  483.     nibble = (((pf[ofs+0] & 0x01))<<3)|
  484.              (((pf[ofs+1] & 0x01))<<2)|
  485.          (((pf[ofs+2] & 0x01))<<1)|
  486.          (((pf[ofs+3] & 0x01)));      
  487.  
  488.     pf_pixel=colour_translation_table[(COLBK & 0xf0) | nibble];
  489.       }
  490.  
  491.       if (pm_pixel) {
  492.     *pf=PixelColor(PF_COLBK,pm_pixel,pf_pixel);
  493.       } else {
  494.     *pf=pf_pixel;
  495.       }
  496.     }
  497. }
  498.  
  499. /* Graphics 10 */
  500. void GTIA_Create80(UBYTE *pm,UBYTE *pf,int ofs)
  501. {
  502. int xpos;
  503. int pm_pixel,pf_pixel=0,nibble=0;
  504.  
  505.     for(xpos=0;xpos<ATARI_WIDTH;xpos++,pm++,pf++) {
  506.       
  507.       pm_pixel = *pm;
  508.  
  509.       if ((xpos & 0x03) == 0x00) {
  510.     nibble = (((pf[ofs+0] & 0x01))<<3)|
  511.              (((pf[ofs+1] & 0x01))<<2)|
  512.              (((pf[ofs+2] & 0x01))<<1)|
  513.              (((pf[ofs+3] & 0x01)));
  514.        
  515.     pf_pixel=colour_lookup[GTIA_XLate[nibble]];      
  516.       }
  517.  
  518.       if (pm_pixel) {
  519.     *pf=PixelColor(nibble,pm_pixel,pf_pixel) & 0xfe;
  520.       } else {
  521.     *pf=pf_pixel & 0xfe;
  522.       }
  523.     }
  524. }
  525.  
  526. void GTIA_CreateC0(UBYTE *pm,UBYTE *pf,int ofs)
  527. {
  528. int xpos;
  529. int pm_pixel,pf_pixel=0,nibble=0;
  530.  
  531.     for(xpos=0;xpos<ATARI_WIDTH;xpos++,pf++,pm++) {
  532.       
  533.       pm_pixel = *pm;
  534.  
  535.       if ((xpos & 0x03) == 0x00) {
  536.     nibble = (((pf[ofs+0] & 0x01))<<3)|
  537.              (((pf[ofs+1] & 0x01))<<2)|
  538.          (((pf[ofs+2] & 0x01))<<1)|
  539.          (((pf[ofs+3] & 0x01)));
  540.     
  541.     if (nibble)
  542.       pf_pixel = colour_translation_table[(nibble << 4) | (COLBK & 0x0f)];
  543.     else
  544.       pf_pixel = colour_translation_table[(nibble << 4)];
  545.       }
  546.  
  547.       if (pm_pixel) {
  548.     *pf=PixelColor(PF_COLBK,pm_pixel,pf_pixel) & 0xfe;
  549.       } else {
  550.     *pf=pf_pixel & 0xfe;
  551.       }
  552.  
  553.     }
  554. }
  555.  
  556.  
  557. void Atari_ScanLine (int hscrol)
  558. {
  559. int ofs=FILLIN_OFFSET;
  560.  
  561.   if (hscrol) {
  562.     ofs -= HSCROL+HSCROL;
  563.   }
  564.  
  565.   POKEY_Scanline();
  566.  
  567.   if (GRAFP0)
  568.     DisplayPlayer(ofs,GRAFP0,global_sizep0,global_hposp0,0);
  569.   
  570.   if (GRAFP1)
  571.     DisplayPlayer(ofs,GRAFP1,global_sizep1,global_hposp1,1);
  572.   
  573.   if (GRAFP2)
  574.     DisplayPlayer(ofs,GRAFP2,global_sizep2,global_hposp2,2);
  575.   
  576.   if (GRAFP3)
  577.     DisplayPlayer(ofs,GRAFP3,global_sizep3,global_hposp3,3);
  578.  
  579.   if (GRAFM)
  580.     DisplayMissiles(ofs);
  581.  
  582.   switch(PRIOR & 0xc0) {
  583.   case 0x00:   /* Ordinary display modes */
  584.     if (artefacts)
  585.       GTIA_Create00AF(pm_scanline+PLAYER_OFFSET,scrn_ptr,ofs);
  586.     else
  587.       GTIA_Create00(pm_scanline+PLAYER_OFFSET,scrn_ptr,ofs);
  588.     break;
  589.   case 0x40:   /* Graphics 9 */
  590.     GTIA_Create40(pm_scanline+PLAYER_OFFSET,scrn_ptr,ofs);
  591.     break;
  592.   case 0x80:   /* Graphics 10 */
  593.     GTIA_Create80(pm_scanline+PLAYER_OFFSET,scrn_ptr,ofs);
  594.     break;
  595.   case 0xc0:   /* Graphics 11 */
  596.     GTIA_CreateC0(pm_scanline+PLAYER_OFFSET,scrn_ptr,ofs);
  597.     break;
  598.   }
  599.  
  600.   memset (pm_scanline, 0, ATARI_MODULO+PLAYER_OFFSET);    
  601. }
  602.  
  603. /* I/O routines for the GTIA */
  604.  
  605. mtype GTIA_CONSOL_GET(void)
  606. {
  607. mtype byte;
  608.  
  609.   if (next_console_value != 7) {
  610.     byte = next_console_value;
  611.     next_console_value = 0x07;
  612.   } else {
  613.     byte = Atari_CONSOL ();
  614.   }
  615.  
  616.   return byte;
  617. }
  618.  
  619. /* Missile-Playfield collisions. These are straight, but sorted reverse */
  620.  
  621. mtype GTIA_M0PF_GET(void)
  622. {
  623.   /* printf("M0PF %x\n",Missile_Playfield[3]); */
  624.   return Missile_Playfield[3];
  625. }
  626.  
  627. mtype GTIA_M1PF_GET(void)
  628. {  
  629.   return Missile_Playfield[2];
  630. }
  631.  
  632. mtype GTIA_M2PF_GET(void)
  633. {  
  634.   /* printf("M2PF %x\n",Missile_Playfield[1]); */
  635.   return Missile_Playfield[1];
  636. }
  637.  
  638. mtype GTIA_M3PF_GET(void)
  639. {  
  640.   return Missile_Playfield[0];
  641. }
  642.  
  643. /* Missile-player collisions. Straight, but sorted in reverse order  */
  644.  
  645. mtype GTIA_M0PL_GET(void)
  646. {
  647.   return Missile_Player[3] & 0x0f;
  648. }
  649.  
  650. mtype GTIA_M1PL_GET(void)
  651. {  
  652.   return Missile_Player[2] & 0x0f;
  653. }
  654.  
  655. mtype GTIA_M2PL_GET(void)
  656. {  
  657.   return Missile_Player[1] & 0x0f;
  658. }
  659.  
  660. mtype GTIA_M3PL_GET(void)
  661. {  
  662.   return Missile_Player[0] & 0x0f;
  663. }
  664.  
  665. /* Player-playfield collisions. Straight. */
  666.  
  667. mtype GTIA_P0PF_GET(void)
  668. {
  669.   return Player_Playfield[0];
  670. }
  671.  
  672. mtype GTIA_P1PF_GET(void)
  673. {
  674.   return Player_Playfield[1];
  675. }
  676.  
  677. mtype GTIA_P2PF_GET(void)
  678. {
  679.   return Player_Playfield[2];
  680. }
  681.  
  682. mtype GTIA_P3PF_GET(void)
  683. {
  684.   return Player_Playfield[3];
  685. }
  686.  
  687. /* Player-player collisions. Wierd. 
  688.    This is simply due to the fact that player zero can't detect collisions with
  689.    other players simply because it is drawn first. 
  690.    We've to extract the proper bits from the collison masks of the other
  691.    players and need to "shuffle" a bit here... */
  692.  
  693. mtype GTIA_P0PL_GET(void)
  694. {
  695. int mask=0;
  696.  
  697.   mask  = (Player_Player[1] & 0x01)<<1;   /* mask in player 1 */
  698.   mask |= (Player_Player[2] & 0x01)<<2;   /* mask in player 2 */
  699.   mask |= (Player_Player[3] & 0x01)<<3;   /* mask in player 3 */
  700.  
  701.   return mask;
  702. }
  703.  
  704. mtype GTIA_P1PL_GET(void)
  705. {
  706. int mask=0;
  707.  
  708.   mask  = (Player_Player[1] & 0x01);      /* mask in player 0 */
  709.   mask |= (Player_Player[2] & 0x02)<<1;   /* mask in player 2 */
  710.   mask |= (Player_Player[3] & 0x02)<<2;   /* mask in player 3 */
  711.  
  712.   return mask;
  713. }
  714.  
  715. mtype GTIA_P2PL_GET(void)
  716. {
  717. int mask=0;
  718.  
  719.   mask  = (Player_Player[2] & 0x03);     /* mask in player 0 and 1 */
  720.   mask |= (Player_Player[3] & 0x04)<<1;  /* mask in player 3 */
  721.  
  722.   return mask;
  723. }
  724.  
  725. mtype GTIA_P3PL_GET(void)
  726. {
  727. int mask=0;
  728.  
  729.   mask  = (Player_Player[3] & 0x07);    /* mask in player 0,1 and 2 */
  730.  
  731.   return mask;
  732. }
  733.  
  734. mtype GTIA_PAL_GET(void)
  735. {
  736.   if (tv_mode == PAL)
  737.     return 0x01;
  738.   else return 0x0f;
  739. }
  740.  
  741. mtype GTIA_TRIG0_GET(void)
  742. {
  743.   return Atari_TRIG(0);
  744. }
  745.  
  746. mtype GTIA_TRIG1_GET(void)
  747. {
  748.   return Atari_TRIG(1);
  749. }
  750.  
  751. mtype GTIA_TRIG2_GET(void)
  752. {
  753.   return Atari_TRIG(2);
  754. }
  755.  
  756. mtype GTIA_TRIG3_GET(void)
  757. {
  758.   if (machine==Atari) return Atari_TRIG (3);
  759.   else                return (CartInserted())?(1):(0);
  760. }
  761.  
  762. int GTIA_COLBK_PUT(mtype byte)
  763. {
  764.   COLBK = byte;
  765.   colour_lookup[8] = colour_translation_table[byte];
  766.   return FALSE;
  767. }
  768.  
  769. int GTIA_COLPF0_PUT(mtype byte)
  770. {
  771.   COLPF0 = byte;
  772.   colour_lookup[4] = colour_translation_table[byte];
  773.   return FALSE;
  774. }
  775.  
  776. int GTIA_COLPF1_PUT(mtype byte)
  777. {
  778.   COLPF1 = byte;
  779.   colour_lookup[5] = colour_translation_table[byte];
  780.   return FALSE;
  781. }
  782.  
  783. int GTIA_COLPF2_PUT(mtype byte)
  784. {
  785.   COLPF2 = byte;
  786.   colour_lookup[6] = colour_translation_table[byte];
  787.   return FALSE;
  788. }
  789.  
  790. int GTIA_COLPF3_PUT(mtype byte)
  791. {
  792.   COLPF3 = byte;
  793.   colour_lookup[7] = colour_translation_table[byte];
  794.   return FALSE;
  795. }
  796.  
  797. int GTIA_COLPM0_PUT(mtype byte)
  798. {
  799.   COLPM0 = byte;
  800.   colour_lookup[0] = colour_translation_table[byte];
  801.   return FALSE;
  802. }
  803.  
  804. int GTIA_COLPM1_PUT(mtype byte)
  805. {
  806.   COLPM1 = byte;
  807.   colour_lookup[1] = colour_translation_table[byte];
  808.   return FALSE;
  809. }
  810.  
  811. int GTIA_COLPM2_PUT(mtype byte)
  812. {
  813.   COLPM2 = byte;
  814.   colour_lookup[2] = colour_translation_table[byte];
  815.   return FALSE;
  816. }
  817.  
  818. int GTIA_COLPM3_PUT(mtype byte)
  819. {
  820.   COLPM3 = byte;
  821.   colour_lookup[3] = colour_translation_table[byte];
  822.   return FALSE;
  823. }
  824.  
  825. int GTIA_GRAFM_PUT(mtype byte)
  826. {
  827.   GRAFM = byte;
  828.   return FALSE;
  829. }
  830.  
  831. int GTIA_GRAFP0_PUT(mtype byte)
  832. {
  833.   GRAFP0 = byte;
  834.   return FALSE;
  835. }
  836.  
  837. int GTIA_GRAFP1_PUT(mtype byte)
  838. {
  839.   GRAFP1 = byte;
  840.   return FALSE;
  841. }
  842.  
  843. int GTIA_GRAFP2_PUT(mtype byte)
  844. {
  845.   GRAFP2 = byte;
  846.   return FALSE;
  847. }
  848.  
  849. int GTIA_GRAFP3_PUT(mtype byte)
  850. {
  851.   GRAFP3 = byte;
  852.   return FALSE;
  853. }
  854.  
  855. int GTIA_HITCLR_PUT(mtype byte)
  856. {
  857.   memset(Player_Player,0,sizeof(UBYTE)*4);
  858.   memset(Player_Playfield,0,sizeof(UBYTE)*4);
  859.   memset(Missile_Player,0,sizeof(UBYTE)*4);
  860.   memset(Missile_Playfield,0,sizeof(UBYTE)*4);
  861.  
  862.   return FALSE;
  863. }
  864.  
  865. int GTIA_HPOSM0_PUT(mtype byte)
  866. {
  867.   HPOSM0 = byte;
  868.   global_hposm[3] = PM_XPos[byte];
  869.   return FALSE;
  870. }
  871.  
  872. int GTIA_HPOSM1_PUT(mtype byte)
  873. {
  874.   HPOSM0 = byte;
  875.   global_hposm[2] = PM_XPos[byte];
  876.   return FALSE;
  877. }
  878.  
  879. int GTIA_HPOSM2_PUT(mtype byte)
  880. {
  881.   HPOSM0 = byte;
  882.   global_hposm[1] = PM_XPos[byte];
  883.   return FALSE;
  884. }
  885.  
  886. int GTIA_HPOSM3_PUT(mtype byte)
  887. {
  888.   HPOSM0 = byte;
  889.   global_hposm[0] = PM_XPos[byte];
  890.   return FALSE;
  891. }
  892.  
  893. int GTIA_HPOSP0_PUT(mtype byte)
  894. {
  895.   HPOSP0 = byte;
  896.   global_hposp0 = PM_XPos[byte];
  897.   return FALSE;
  898. }
  899.  
  900. int GTIA_HPOSP1_PUT(mtype byte)
  901. {
  902.   HPOSP1 = byte;
  903.   global_hposp1 = PM_XPos[byte];
  904.   return FALSE;
  905. }
  906.  
  907. int GTIA_HPOSP2_PUT(mtype byte)
  908. {
  909.   HPOSP2 = byte;
  910.   global_hposp2 = PM_XPos[byte];
  911.   return FALSE;
  912. }
  913.  
  914. int GTIA_HPOSP3_PUT(mtype byte)
  915. {
  916.   HPOSP3 = byte;
  917.   global_hposp3 = PM_XPos[byte];
  918.   return FALSE;
  919. }
  920.  
  921. int GTIA_SIZEM_PUT(mtype byte)
  922. {
  923.   SIZEM = byte;  
  924.  
  925. /* We extract now the proper sizes of the missiles. Easier to do here than on
  926.    every scan line since this register isn't written to "too often". */
  927.  
  928.   global_sizem[3] = PM_Width[byte & 0x03];     
  929.   global_sizem[2] = PM_Width[(byte >> 2) & 0x03];
  930.   global_sizem[1] = PM_Width[(byte >> 4) & 0x03];
  931.   global_sizem[0] = PM_Width[(byte >> 6) & 0x03];
  932.  
  933.   return FALSE;
  934. }
  935.  
  936. int GTIA_SIZEP0_PUT(mtype byte)
  937. {
  938.   SIZEP0 = byte;
  939.   global_sizep0 = PM_Width[byte & 0x03];
  940.   return FALSE;
  941. }
  942.  
  943. int GTIA_SIZEP1_PUT(mtype byte)
  944. {
  945.   SIZEP1 = byte;
  946.   global_sizep1 = PM_Width[byte & 0x03];
  947.   return FALSE;
  948. }
  949.  
  950. int GTIA_SIZEP2_PUT(mtype byte)
  951. {
  952.   SIZEP2 = byte;
  953.   global_sizep2 = PM_Width[byte & 0x03];
  954.   return FALSE;
  955. }
  956.  
  957. int GTIA_SIZEP3_PUT(mtype byte)
  958. {
  959.   SIZEP3 = byte;
  960.   global_sizep3 = PM_Width[byte & 0x03];
  961.   return FALSE;
  962. }
  963.  
  964. int GTIA_PRIOR_PUT(mtype byte)
  965. {
  966.   PRIOR = byte;
  967.   Setup_Priority();
  968.   return FALSE;
  969. }
  970.  
  971. int GTIA_GRACTL_PUT(mtype byte)
  972. {
  973.   GRACTL = byte;
  974.   return FALSE;
  975. }
  976.  
  977. int GTIA_VDELAY_PUT(mtype byte)
  978. {
  979.   VDELAY = byte;
  980.  
  981. /* Calculate the delay for each player/missile */
  982.  
  983.   delaym0 = byte;
  984.   delaym1 = byte>>1;
  985.   delaym2 = byte>>2;
  986.   delaym3 = byte>>3;
  987.   delayp0 = byte>>4;
  988.   delayp1 = byte>>5;
  989.   delayp2 = byte>>6;
  990.   delayp3 = byte>>7;
  991.  
  992.   delaym0 &= 0x01;
  993.   delaym1 &= 0x01;
  994.   delaym2 &= 0x01;
  995.   delaym3 &= 0x01;
  996.  
  997.   delayp0 &= 0x01;
  998.   delayp1 &= 0x01;
  999.   delayp2 &= 0x01;
  1000.   delayp3 &= 0x01;
  1001.  
  1002.   return FALSE;
  1003. }
  1004.  
  1005. void Init_GTIA(int *argc, char **argv,int base)
  1006. {
  1007.   int i,j;
  1008.  
  1009.   if (argc) {
  1010.     artefacts = FALSE;
  1011.     for (i=j=1;i<*argc;i++) {
  1012.       if (strcmp(argv[i],"-artefacts") == 0)
  1013.     artefacts = TRUE;
  1014.       else
  1015.     argv[j++] = argv[i];
  1016.     }    
  1017.     *argc = j;
  1018.   }  
  1019.  
  1020.   for (i=0x00;i<256;i++)
  1021.     PM_XPos[i] = (i - 0x20) << 1;
  1022.  
  1023.   for (i=0;i<9;i++)
  1024.     colour_lookup[i] = 0x00;
  1025.  
  1026.   PRIOR = 0x00;
  1027.   Setup_Priority();
  1028.  
  1029.   SetHW(base+_HPOSP0,0xff1f,>IA_M0PF_GET,>IA_HPOSP0_PUT);
  1030.   SetHW(base+_HPOSP1,0xff1f,>IA_M1PF_GET,>IA_HPOSP1_PUT);
  1031.   SetHW(base+_HPOSP2,0xff1f,>IA_M2PF_GET,>IA_HPOSP2_PUT);
  1032.   SetHW(base+_HPOSP3,0xff1f,>IA_M3PF_GET,>IA_HPOSP3_PUT);
  1033.   SetHW(base+_HPOSM0,0xff1f,>IA_P0PF_GET,>IA_HPOSM0_PUT);
  1034.   SetHW(base+_HPOSM1,0xff1f,>IA_P1PF_GET,>IA_HPOSM1_PUT);
  1035.   SetHW(base+_HPOSM2,0xff1f,>IA_P2PF_GET,>IA_HPOSM2_PUT);
  1036.   SetHW(base+_HPOSM3,0xff1f,>IA_P3PF_GET,>IA_HPOSM3_PUT);
  1037.   SetHW(base+_SIZEP0,0xff1f,>IA_M0PL_GET,>IA_SIZEP0_PUT);
  1038.   SetHW(base+_SIZEP1,0xff1f,>IA_M1PL_GET,>IA_SIZEP1_PUT);
  1039.   SetHW(base+_SIZEP2,0xff1f,>IA_M2PL_GET,>IA_SIZEP2_PUT);
  1040.   SetHW(base+_SIZEP3,0xff1f,>IA_M3PL_GET,>IA_SIZEP3_PUT);
  1041.   SetHW(base+_SIZEM ,0xff1f,>IA_P0PL_GET,>IA_SIZEM_PUT );
  1042.   SetHW(base+_GRAFP0,0xff1f,>IA_P1PL_GET,>IA_GRAFP0_PUT);
  1043.   SetHW(base+_GRAFP1,0xff1f,>IA_P2PL_GET,>IA_GRAFP1_PUT);
  1044.   SetHW(base+_GRAFP2,0xff1f,>IA_P3PL_GET,>IA_GRAFP2_PUT);
  1045.   SetHW(base+_GRAFP3,0xff1f,>IA_TRIG0_GET,>IA_GRAFP3_PUT);
  1046.   SetHW(base+_GRAFM,0xff1f,>IA_TRIG1_GET,>IA_GRAFM_PUT);
  1047.   SetHW(base+_COLPM0,0xff1f,>IA_TRIG2_GET,>IA_COLPM0_PUT);
  1048.   SetHW(base+_COLPM1,0xff1f,>IA_TRIG3_GET,>IA_COLPM1_PUT);
  1049.   SetHW(base+_COLPM2,0xff1f,>IA_PAL_GET,>IA_COLPM2_PUT);
  1050.   SetHW(base+_COLPM3,0xff1f,NULL,>IA_COLPM3_PUT);
  1051.   SetHW(base+_COLPF0,0xff1f,NULL,>IA_COLPF0_PUT);
  1052.   SetHW(base+_COLPF1,0xff1f,NULL,>IA_COLPF1_PUT);
  1053.   SetHW(base+_COLPF2,0xff1f,NULL,>IA_COLPF2_PUT);
  1054.   SetHW(base+_COLPF3,0xff1f,NULL,>IA_COLPF3_PUT);
  1055.   SetHW(base+_COLBK,0xff1f,NULL,>IA_COLBK_PUT);
  1056.   SetHW(base+_PRIOR,0xff1f,NULL,>IA_PRIOR_PUT);
  1057.   SetHW(base+_VDELAY,0xff1f,NULL,>IA_VDELAY_PUT);
  1058.   SetHW(base+_GRACTL,0xff1f,NULL,>IA_GRACTL_PUT);
  1059.   SetHW(base+_HITCLR,0xff1f,NULL,>IA_HITCLR_PUT);
  1060.   SetHW(base+_CONSOL,0xff1f,>IA_CONSOL_GET,NULL);
  1061.  
  1062. }
  1063.